/*
 *********************************************************************************************************
 *                                                uC/OS-II
 *                                          The Real-Time Kernel
 *                                             TIME MANAGEMENT
 *
 *                          (c) Copyright 1992-2006, Jean J. Labrosse, Weston, FL
 *                                           All Rights Reserved
 *
 * File    : OS_TIME.C
 * By      : Jean J. Labrosse
 * Version : V2.83
 *********************************************************************************************************
 */

#ifndef  OS_MASTER_FILE
#include <ucos_ii.h>
#endif

/*
 *********************************************************************************************************
 *                                DELAY TASK 'n' TICKS   (n from 0 to 65535)
 *
 * Description: This function is called to delay execution of the currently running task until the
 *              specified number of system ticks expires.  This, of course, directly equates to delaying
 *              the current task for some time to expire.  No delay will result If the specified delay is
 *              0.  If the specified delay is greater than 0 then, a context switch will result.
 *
 * Arguments  : ticks     is the time delay that the task will be suspended in number of clock 'ticks'.
 *                        Note that by specifying 0, the task will not be delayed.
 *
 * Returns    : none
 *********************************************************************************************************
 */

void  OSTimeDly(INT16U ticks)
{
    INT8U y;

#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
    OS_CPU_SR cpu_sr = 0;
#endif



    if (ticks > 0)                               /* 0 means no delay!                                  */
    {
        OS_ENTER_CRITICAL();
        y            =  OSTCBCur->OSTCBY;        /* Delay current task                                 */
        OSRdyTbl[y] &= ~OSTCBCur->OSTCBBitX;
        if (OSRdyTbl[y] == 0)
        {
            OSRdyGrp &= ~OSTCBCur->OSTCBBitY;
        }
        OSTCBCur->OSTCBDly = ticks;              /* Load ticks in TCB                                  */
        OS_EXIT_CRITICAL();
        OS_Sched();                              /* Find next task to run!                             */
    }
}
/*$PAGE*/
/*
 *********************************************************************************************************
 *                                     DELAY TASK FOR SPECIFIED TIME
 *
 * Description: This function is called to delay execution of the currently running task until some time
 *              expires.  This call allows you to specify the delay time in HOURS, MINUTES, SECONDS and
 *              MILLISECONDS instead of ticks.
 *
 * Arguments  : hours     specifies the number of hours that the task will be delayed (max. is 255)
 *              minutes   specifies the number of minutes (max. 59)
 *              seconds   specifies the number of seconds (max. 59)
 *              milli     specifies the number of milliseconds (max. 999)
 *
 * Returns    : OS_NO_ERR
 *              OS_TIME_INVALID_MINUTES
 *              OS_TIME_INVALID_SECONDS
 *              OS_TIME_INVALID_MS
 *              OS_TIME_ZERO_DLY
 *
 * Note(s)    : The resolution on the milliseconds depends on the tick rate.  For example, you can't do
 *              a 10 mS delay if the ticker interrupts every 100 mS.  In this case, the delay would be
 *              set to 0.  The actual delay is rounded to the nearest tick.
 *********************************************************************************************************
 */

#if OS_TIME_DLY_HMSM_EN > 0
INT8U  OSTimeDlyHMSM(INT8U hours, INT8U minutes, INT8U seconds, INT16U milli)
{
    INT32U ticks;
    INT16U loops;


#if OS_ARG_CHK_EN > 0
    if (hours == 0)
    {
        if (minutes == 0)
        {
            if (seconds == 0)
            {
                if (milli == 0)
                {
                    return OS_TIME_ZERO_DLY;
                }
            }
        }
    }
    if (minutes > 59)
    {
        return OS_TIME_INVALID_MINUTES;          /* Validate arguments to be within range              */
    }
    if (seconds > 59)
    {
        return OS_TIME_INVALID_SECONDS;
    }
    if (milli > 999)
    {
        return OS_TIME_INVALID_MILLI;
    }
#endif
    /* Compute the total number of clock ticks required.. */
    /* .. (rounded to the nearest tick)                   */
    ticks = ((INT32U)hours * 3600L + (INT32U)minutes * 60L + (INT32U)seconds) * OS_TICKS_PER_SEC
            + OS_TICKS_PER_SEC * ((INT32U)milli + 500L / OS_TICKS_PER_SEC) / 1000L;
    loops = (INT16U)(ticks / 65536L);            /* Compute the integral number of 65536 tick delays   */
    ticks = ticks % 65536L;                      /* Obtain  the fractional number of ticks             */
    OSTimeDly((INT16U)ticks);
    while (loops > 0)
    {
        OSTimeDly((INT16U)32768u);
        OSTimeDly((INT16U)32768u);
        loops--;
    }
    return OS_NO_ERR;
}
#endif
/*$PAGE*/
/*
 *********************************************************************************************************
 *                                         RESUME A DELAYED TASK
 *
 * Description: This function is used resume a task that has been delayed through a call to either
 *              OSTimeDly() or OSTimeDlyHMSM().  Note that you can call this function to resume a
 *              task that is waiting for an event with timeout.  This would make the task look
 *              like a timeout occurred.
 *
 *              Also, you cannot resume a task that has called OSTimeDlyHMSM() with a combined time that
 *              exceeds 65535 clock ticks.  In other words, if the clock tick runs at 100 Hz then, you will
 *              not be able to resume a delayed task that called OSTimeDlyHMSM(0, 10, 55, 350) or higher:
 *
 *                  (10 Minutes * 60 + 55 Seconds + 0.35) * 100 ticks/second.
 *
 * Arguments  : prio                      specifies the priority of the task to resume
 *
 * Returns    : OS_NO_ERR                 Task has been resumed
 *              OS_PRIO_INVALID           if the priority you specify is higher that the maximum allowed
 *                                        (i.e. >= OS_LOWEST_PRIO)
 *              OS_TIME_NOT_DLY           Task is not waiting for time to expire
 *              OS_TASK_NOT_EXIST         The desired task has not been created or has been assigned to a Mutex.
 *********************************************************************************************************
 */

#if OS_TIME_DLY_RESUME_EN > 0
INT8U  OSTimeDlyResume(INT8U prio)
{
    OS_TCB    *ptcb;

#if OS_CRITICAL_METHOD == 3                                    /* Storage for CPU status register      */
    OS_CPU_SR cpu_sr = 0;
#endif



    if (prio >= OS_LOWEST_PRIO)
    {
        return OS_PRIO_INVALID;
    }
    OS_ENTER_CRITICAL();
    ptcb = OSTCBPrioTbl[prio];                                 /* Make sure that task exist            */
    if (ptcb == (OS_TCB*)0)
    {
        OS_EXIT_CRITICAL();
        return OS_TASK_NOT_EXIST;                              /* The task does not exist              */
    }
    if (ptcb == (OS_TCB*)1)
    {
        OS_EXIT_CRITICAL();
        return OS_TASK_NOT_EXIST;                              /* The task does not exist              */
    }
    if (ptcb->OSTCBDly == 0)                                   /* See if task is delayed               */
    {
        OS_EXIT_CRITICAL();
        return OS_TIME_NOT_DLY;                                /* Indicate that task was not delayed   */
    }

    ptcb->OSTCBDly = 0;                                        /* Clear the time delay                 */
    if ((ptcb->OSTCBStat & OS_STAT_PEND_ANY) != OS_STAT_RDY)
    {
        ptcb->OSTCBStat   &= ~OS_STAT_PEND_ANY;                /* Yes, Clear status flag               */
        ptcb->OSTCBPendTO  = OS_TRUE;                          /* Indicate PEND timeout                */
    }
    else
    {
        ptcb->OSTCBPendTO  = OS_FALSE;
    }
    if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY)    /* Is task suspended?                   */
    {
        OSRdyGrp               |= ptcb->OSTCBBitY;             /* No,  Make ready                      */
        OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
        OS_EXIT_CRITICAL();
        OS_Sched();                                           /* See if this is new highest priority   */
    }
    else
    {
        OS_EXIT_CRITICAL();                                   /* Task may be suspended                 */
    }
    return OS_NO_ERR;
}
#endif
/*$PAGE*/
/*
 *********************************************************************************************************
 *                                         GET CURRENT SYSTEM TIME
 *
 * Description: This function is used by your application to obtain the current value of the 32-bit
 *              counter which keeps track of the number of clock ticks.
 *
 * Arguments  : none
 *
 * Returns    : The current value of OSTime
 *********************************************************************************************************
 */

#if OS_TIME_GET_SET_EN > 0
INT32U  OSTimeGet(void)
{
    INT32U ticks;

#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
    OS_CPU_SR cpu_sr = 0;
#endif



    OS_ENTER_CRITICAL();
    ticks = OSTime;
    OS_EXIT_CRITICAL();
    return ticks;
}
#endif

/*
 *********************************************************************************************************
 *                                            SET SYSTEM CLOCK
 *
 * Description: This function sets the 32-bit counter which keeps track of the number of clock ticks.
 *
 * Arguments  : ticks      specifies the new value that OSTime needs to take.
 *
 * Returns    : none
 *********************************************************************************************************
 */

#if OS_TIME_GET_SET_EN > 0
void  OSTimeSet(INT32U ticks)
{
#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
    OS_CPU_SR cpu_sr = 0;
#endif



    OS_ENTER_CRITICAL();
    OSTime = ticks;
    OS_EXIT_CRITICAL();
}
#endif
